/**
 * 任务服务
 * Ver : CCMiniCloud Framework 2.0.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2024-08-28 08:00:00 
 */

const BaseService = require('./base_service.js');
const util = require('../../../framework/helpers/util.js');
const cloudUtil = require('../../../framework/cloud/cloud_util.js');
const TaskModel = require('../model/task_model.js');
const ProjectModel = require('../model/project_model.js');
const timeUtil = require('../../../framework/helpers/time_util.js');

class TaskService extends BaseService {

	/**
	 * 构造函数
	 */
	constructor() {
		super();
		this._taskModel = new TaskModel();
		this._projectModel = new ProjectModel();
	}

	/**
	 * 创建任务
	 * @param {object} params 任务参数
	 */
	async createTask(params) {
		// 数据校验
		if (!params.task_project_id)
			throw new Error('项目ID不能为空');

		if (!params.task_title)
			throw new Error('任务标题不能为空');

		// 任务编号
		params.task_id = this.genTaskId();

		// 处理时间字段
		if (params.task_start_time)
			params.task_start_time = timeUtil.time2Timestamp(params.task_start_time);

		if (params.task_end_time)
			params.task_end_time = timeUtil.time2Timestamp(params.task_end_time);

		// 参数预处理
		params.task_create_time = this._timestamp;

		// 保存到数据库
		const id = await this._taskModel.insert(params);
		return { id, task_id: params.task_id };
	}

	/**
	 * 生成任务编号
	 */
	genTaskId() {
		return 'T' + timeUtil.time('YMDhms') + util.genRandomString(4);
	}

	/**
	 * 批量创建任务
	 * @param {string} projectId 项目ID
	 * @param {array} tasks 任务列表
	 */
	async batchCreateTasks(projectId, tasks) {
		if (!projectId) throw new Error('项目ID不能为空');
		if (!Array.isArray(tasks) || tasks.length === 0) 
			throw new Error('任务数据无效');

		// 检查项目是否存在
		const projectExists = await this._projectModel.isExist({ _id: projectId });
		if (!projectExists) throw new Error('项目不存在');

		const timestamp = this._timestamp;
		const insertData = tasks.map(task => {
			// 参数预处理
			return {
				task_id: this.genTaskId(),
				task_project_id: projectId,
				task_title: task.title || '未命名任务',
				task_desc: task.desc || '',
				task_priority: task.priority || 5,
				task_required: task.required || false,
				task_assign: task.assign || '',
				task_create_time: timestamp,
				task_status: 0, // 初始状态为未开始
				task_progress: 0, // 初始进度为0
				task_project_status: task.projectStatus || '',
				task_start_time: task.startTime ? timeUtil.time2Timestamp(task.startTime) : 0,
				task_end_time: task.endTime ? timeUtil.time2Timestamp(task.endTime) : 0
			};
		});

		// 批量插入数据库
		const result = await this._taskModel.insertBatch(insertData);
		return result;
	}

	/**
	 * 创建项目状态关联任务
	 * @param {string} projectId 项目ID
	 * @param {string} projectStatus 项目状态
	 * @param {array} tasks 任务列表
	 */
	async createProjectStatusTasks(projectId, projectStatus, tasks) {
		if (!projectId || !projectStatus)
			throw new Error('项目ID和状态不能为空');

		if (!Array.isArray(tasks) || tasks.length === 0) 
			return [];

		// 为每个任务添加项目状态关联
		const timestamp = this._timestamp;
		const insertData = tasks.map(task => {
			return {
				task_id: this.genTaskId(),
				task_project_id: projectId,
				task_project_status: projectStatus,
				task_title: task.title || '未命名任务',
				task_desc: task.desc || '',
				task_priority: task.priority || 5,
				task_required: task.required || false,
				task_assign: task.assign || '',
				task_create_time: timestamp,
				task_status: 0, // 初始状态为未开始
				task_progress: 0, // 初始进度为0
				task_start_time: task.startTime ? timeUtil.time2Timestamp(task.startTime) : 0,
				task_end_time: task.endTime ? timeUtil.time2Timestamp(task.endTime) : 0
			};
		});

		// 批量插入数据库
		const result = await this._taskModel.insertBatch(insertData);
		return result;
	}

	/**
	 * 检查项目转换条件
	 * @param {string} projectId 项目ID
	 */
	async checkProjectTransitionCondition(projectId) {
		if (!projectId) throw new Error('项目ID不能为空');
		return await this._taskModel.checkProjectTransitionCondition(projectId);
	}

	/**
	 * 更新任务状态
	 * @param {string} taskId 任务ID
	 * @param {number} status 状态
	 * @param {number} progress 进度
	 * @param {string} userId 操作用户ID
	 */
	async updateTaskStatus(taskId, status, progress, userId) {
		if (!taskId) throw new Error('任务ID不能为空');
		
		// 查询任务是否存在
		const task = await this._taskModel.getOne({ _id: taskId });
		if (!task) throw new Error('任务不存在');
		
		// 验证状态参数
		if (![0, 1, 2, 3].includes(status)) 
			throw new Error('无效的任务状态');
			
		// 验证进度参数
		if (progress !== undefined && (progress < 0 || progress > 100))
			throw new Error('任务进度必须在0-100之间');

		// 准备更新数据
		const data = {
			task_status: status,
			task_update_time: this._timestamp,
			task_update_by: userId || ''
		};
		
		// 如果提供了进度，更新进度
		if (progress !== undefined) {
			data.task_progress = progress;
		} else {
			// 根据状态自动设置进度
			switch (status) {
				case 0: // 未开始
					data.task_progress = 0;
					break;
				case 1: // 进行中
					// 如果当前是未开始状态，设置初始进度为10%
					if (task.task_status === 0) {
						data.task_progress = 10;
					}
					break;
				case 2: // 已完成
					data.task_progress = 100;
					break;
				case 3: // 已取消
					// 保持原进度不变
					break;
			}
		}
		
		// 更新数据库
		await this._taskModel.edit({ _id: taskId }, data);
		
		// 返回更新后的数据
		return {
			id: taskId,
			status: data.task_status,
			progress: data.task_progress
		};
	}

	/**
	 * 获取项目任务列表
	 * @param {object} params 查询参数
	 */
	async getProjectTasks(params) {
		// 参数校验
		if (!params.projectId) throw new Error('项目ID不能为空');

		// 构建查询选项
		const options = {
			status: params.status !== undefined ? Number(params.status) : -1,
			search: params.search || '',
			sortType: params.sortType || 'time',
			sortVal: params.sortVal !== undefined ? Number(params.sortVal) : 1,
			page: params.page ? Number(params.page) : 1,
			size: params.size ? Number(params.size) : 10
		};

		// 查询数据
		const result = await this._taskModel.getProjectTaskList(params.projectId, options);
		
		// 处理返回数据
		result.list = result.list.map(task => {
			// 转换时间戳为格式化时间
			if (task.task_create_time) {
				task.task_create_time_format = timeUtil.timestamp2Time(task.task_create_time);
			}
			
			if (task.task_start_time) {
				task.task_start_time_format = timeUtil.timestamp2Time(task.task_start_time);
			}
			
			if (task.task_end_time) {
				task.task_end_time_format = timeUtil.timestamp2Time(task.task_end_time);
			}
			
			return task;
		});
		
		return result;
	}

	/**
	 * 获取任务统计数据
	 * @param {string} projectId 项目ID
	 */
	async getTaskStats(projectId) {
		if (!projectId) throw new Error('项目ID不能为空');
		return await this._taskModel.getTaskStats(projectId);
	}

	/**
	 * 获取用户任务列表
	 * @param {object} params 查询参数
	 */
	async getMyTasks(params) {
		// 参数校验
		if (!params.userId) throw new Error('用户ID不能为空');

		// 构建查询选项
		const options = {
			status: params.status !== undefined ? Number(params.status) : -1,
			search: params.search || '',
			sortType: params.sortType || 'time',
			sortVal: params.sortVal !== undefined ? Number(params.sortVal) : 1,
			page: params.page ? Number(params.page) : 1,
			size: params.size ? Number(params.size) : 10
		};

		// 查询数据
		const result = await this._taskModel.getMyTaskList(params.userId, options);
		
		// 处理返回数据
		result.list = result.list.map(task => {
			// 转换时间戳为格式化时间
			if (task.task_create_time) {
				task.task_create_time_format = timeUtil.timestamp2Time(task.task_create_time);
			}
			
			if (task.task_start_time) {
				task.task_start_time_format = timeUtil.timestamp2Time(task.task_start_time);
			}
			
			if (task.task_end_time) {
				task.task_end_time_format = timeUtil.timestamp2Time(task.task_end_time);
			}
			
			return task;
		});
		
		return result;
	}

	/**
	 * 获取任务详情
	 * @param {string} taskId 任务ID
	 */
	async getTaskDetail(taskId) {
		if (!taskId) throw new Error('任务ID不能为空');
		
		const task = await this._taskModel.getOne({ _id: taskId });
		if (!task) throw new Error('任务不存在');
		
		// 转换时间戳为格式化时间
		if (task.task_create_time) {
			task.task_create_time_format = timeUtil.timestamp2Time(task.task_create_time);
		}
		
		if (task.task_start_time) {
			task.task_start_time_format = timeUtil.timestamp2Time(task.task_start_time);
		}
		
		if (task.task_end_time) {
			task.task_end_time_format = timeUtil.timestamp2Time(task.task_end_time);
		}
		
		// 查询关联的项目信息
		if (task.task_project_id) {
			const projectInfo = await this._projectModel.getOne({ _id: task.task_project_id });
			if (projectInfo) {
				task.project_info = {
					id: task.task_project_id,
					title: projectInfo.project_title
				};
			}
		}
		
		return task;
	}

	/**
	 * 删除任务
	 * @param {string} taskId 任务ID
	 */
	async deleteTask(taskId) {
		if (!taskId) throw new Error('任务ID不能为空');
		return await this._taskModel.del({ _id: taskId });
	}

	/**
	 * 删除项目任务
	 * @param {string} projectId 项目ID
	 */
	async deleteProjectTasks(projectId) {
		if (!projectId) throw new Error('项目ID不能为空');
		return await this._taskModel.deleteProjectTasks(projectId);
	}

}

module.exports = TaskService; 